#include "../coredef.h"
#include "cppdef.h"

typedef struct _PPTOKENBLOCK{
	AST 	astStart;		/*開始の添え字*/
	AST     astEnd;
	AST 	astCurr;		/*解析した前処理トークン数  */
}PPTOKENBLOCK;

/************************************************************************/
/*  定数																	*/
/************************************************************************/
#define cMAXBUFFERSIZE 			2048

/************************************************************************/
/*  グローバル変数															*/
/************************************************************************/
typedef struct _WORKSYMCONV {
	PPTOKENBLOCK	stSrcBlock;
	PPTOKENBLOCK	stDstBlock;
	PPTOKENBLOCK	stArgSrcBlock;
	PPTOKENBLOCK	stArgDstBlock;
	AST				astMacroDefInfo;
	AST				astCodeScope;
	AST				astTmpMacroCall;
}WORKSYMCONV, *PWORKSYMCONV;
static CHAR	chNameBuffer[cMAXBUFFERSIZE];	/* 名前バッファー */

/************************************************************************/
/*  関数																	*/
/************************************************************************/
static S4 cppRepNewMacroArgInfo( S4 index, AST start, AST end )
{
	AST astArgCntNow;
	/*テーブルKIND_MACROARGINFOに1行を追加する*/

	FATAL_ON_FALSE(stCppMcrArgInfoAccess.alloc(1));

	/*テーブルKIND_MACROARGINFOの行の総数を「現在の実引数情報」に設定する*/
	astArgCntNow = stCppMcrArgInfoAccess.getMax();

	/*テーブルKIND_MACROARGINFOの「現在の実引数情報」行目のLONG_ARGINDEX属性に(*pastArgCnt)を設定する　*/
	stCppMcrArgInfoAccess.index.set(astArgCntNow, index );

	/*テーブルKIND_MACROARGINFOの「現在の実引数情報」行目のIDX_STARTPPTOKEN属性に「引数開始前処理字句」を設定する*/
	stCppMcrArgInfoAccess.begin.set(astArgCntNow, start);

	/*テーブルKIND_MACROARGINFOの「現在の実引数情報」行目のIDX_ENDPPTOKEN属性に「引数終了前処理字句」を設定する　*/
	stCppMcrArgInfoAccess.end.set(astArgCntNow, end);
	return COEXIT_SUCCESS;
}
/************************************************************************/
/* 関 数 名 : 	cppRepSetOtherLoc											*/
/* 機    能 :																*/
/* 引 き 数 : 	astToken													*/
/*			astOtherLoc													*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
//static S4 cppRepSetOtherLoc( AST astToken, AST astOtherLoc )
//{
//	return COEXIT_SUCCESS;
//}
/************************************************************************/
/* 関 数 名 : 	cppRepInsidePar												*/
/* 機    能 :																*/
/* 引 き 数 : 	なし															*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
static S4 cppRepInsidePar(void)
{
	S4 	iRet;
	U2 	usPPKind;

	iRet = CppTokenGetNextToken( FALSE, TRUE );

	while( iRet == COEXIT_SUCCESS )
	{
		/*現在のUSHORT_PPTOKENKINDを取得*/
		usPPKind = stCppTokenAccess.tokenKind.get( CUR_TOKEN_INDEX );

		/* ')' の場合 */
		if( usPPKind == xPPTOKEN_CLOSEPAREN )
		{
			iRet = CppTokenGetNextToken( FALSE, TRUE );
			break;
		}
		/* '('の場合 */
		if( usPPKind == xPPTOKEN_OPENPAREN )
		{
			iRet = cppRepInsidePar();
		}
		else
		{
			iRet = CppTokenGetNextToken( FALSE, TRUE );
		}
	}
	return (iRet);
}


/************************************************************************/
/* 関 数 名 : 	cppRepTmpInsidePar											*/
/* 機    能 :																*/
/* 引 き 数 : 	pastStart			開始トークン								*/
/*			astEnd				終了トークン								*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
static S4 cppRepTmpInsidePar(AST *pastStart, AST astEnd)
{
	S4 	iRet = 0;
	U2 	usPPKind = 0;

	(*pastStart)++;
	if( (*pastStart) > astEnd )
	{
		return COEXIT_FINISHED;
	}

	while( (*pastStart) <= astEnd )
	{
		/*現在のUSHORT_PPTOKENKINDを取得*/
		usPPKind = stCppTokenAccess.tokenKind.get(  *pastStart );

		if( usPPKind == xPPTOKEN_CLOSEPAREN )
		{
			/* ')' の場合 */
			(*pastStart)++;
			if( (*pastStart) > astEnd )
			{
				return COEXIT_FINISHED;
			}
			break;
		}
		else if( usPPKind == xPPTOKEN_OPENPAREN )
		{
			/* '('の場合 */
			iRet = cppRepTmpInsidePar( pastStart, astEnd );
			if( iRet != COEXIT_SUCCESS )
			{
				return (iRet);
			}
		}
		else
		{
			(*pastStart)++;
			if( (*pastStart) > astEnd )
			{
				return COEXIT_FINISHED;
			}
		}
	}
	return (iRet);
}


/************************************************************************/
/* 関 数 名 : 	cppRepGetArg												*/
/* 機    能 :																*/
/* 引 き 数 : 	plArgCnt			実引数の数								*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_WARNING		警告終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
static S4 cppRepGetArg(AST astMacroDef, S4 *plArgCnt)
{
	S4		iFuncRet;				/* 戻り値 */
	U2 	usPPKind;				/* 前処理字句種類 */
	AST 	astPreArgToken;  		/* 引数開始前処理字句 */
	AST 	astAftArgToken;			/* 引数終了前処理字句 */
	BOOL    bVariable = stCoreMacroDefInfoAccess.bVariableParam.get( astMacroDef );
	S4      s4ArgCnt = stCoreMacroDefInfoAccess.paramNum.get( astMacroDef );
	BOOL    bSkipComma = FALSE;


	*plArgCnt = -1;

	iFuncRet = CppTokenGetNextToken( TRUE, TRUE );
	if( iFuncRet != COEXIT_SUCCESS )
	{
		return (iFuncRet);
	}

	/*現在の前処理字句の前処理字句種類を取得*/
	usPPKind = stCppTokenAccess.tokenKind.get( CUR_TOKEN_INDEX );
	if( usPPKind != xPPTOKEN_OPENPAREN )
	{
		return COEXIT_SUCCESS;
	}

	iFuncRet = CppTokenGetNextToken( TRUE, TRUE );
	if( iFuncRet != COEXIT_SUCCESS )
	{
		return (iFuncRet);
	}

	*plArgCnt = 0;
	if( bVariable == TRUE && (*plArgCnt) >= (s4ArgCnt - 1) )
	{
		bSkipComma = TRUE;
	}
	/*「引数開始前処理字句」に　TOKENINDEXを代入する*/
	astPreArgToken = CUR_TOKEN_INDEX;

	while( iFuncRet == COEXIT_SUCCESS )
	{
		/*現在の前処理字句の前処理字句種類を取得*/
		usPPKind = stCppTokenAccess.tokenKind.get( CUR_TOKEN_INDEX );

		if( usPPKind == xPPTOKEN_CLOSEPAREN )
		{
			/*「引数開始前処理字句」行目の前処理字句種類を取得*/
			usPPKind = stCppTokenAccess.tokenKind.get( astPreArgToken );

			while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
			{
				/*「引数開始前処理字句」++*/
				astPreArgToken++;
				usPPKind = stCppTokenAccess.tokenKind.get( astPreArgToken );
			}
			/*「引数終了前処理字句」　=　TOKENINDEX　-　1*/
			astAftArgToken = CUR_TOKEN_INDEX - 1;

			if( astPreArgToken <= astAftArgToken )
			{
				usPPKind = stCppTokenAccess.tokenKind.get( astAftArgToken );
				while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
				{
					astAftArgToken--;
					if( astPreArgToken > astAftArgToken )
					{
						break;
					}
					usPPKind =  stCppTokenAccess.tokenKind.get( astAftArgToken );
				}
			}

			if( astPreArgToken > astAftArgToken )
			{
				astPreArgToken = 0;
				astAftArgToken = 0;
			}else{
				(*plArgCnt)++;
				if( bVariable == TRUE && (*plArgCnt) >= (s4ArgCnt - 1) )
				{
					bSkipComma = TRUE;
				}
				iFuncRet = cppRepNewMacroArgInfo( (*plArgCnt), astPreArgToken, astAftArgToken );
				if( iFuncRet != COEXIT_SUCCESS )
				{
					return (iFuncRet);
				}
			}
			usPPKind = xPPTOKEN_CLOSEPAREN;
			break;
		}
		else if( usPPKind == xPPTOKEN_OPENPAREN )
		{
			iFuncRet = cppRepInsidePar();
		}
		else if( bSkipComma == FALSE && usPPKind == xPPTOKEN_COMMA )
		{
			/*「引数開始前処理字句」行目の前処理字句種類を取得*/
			usPPKind = stCppTokenAccess.tokenKind.get( astPreArgToken );

			while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
			{
				/*「引数開始前処理字句」++*/
				astPreArgToken++;
				usPPKind = stCppTokenAccess.tokenKind.get( astPreArgToken );
			}
			/*「引数終了前処理字句」　=　TOKENINDEX　-　1*/
			astAftArgToken = CUR_TOKEN_INDEX - 1;

			if( astPreArgToken <= astAftArgToken )
			{
				usPPKind = stCppTokenAccess.tokenKind.get( astAftArgToken );
				while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
				{
					astAftArgToken--;
					if( astPreArgToken > astAftArgToken )
					{
						break;
					}
					usPPKind =  stCppTokenAccess.tokenKind.get( astAftArgToken );
				}
			}

			if( astPreArgToken > astAftArgToken )
			{
				astPreArgToken = 0;
				astAftArgToken = 0;
			}
			(*plArgCnt)++;
			if( bVariable == TRUE && (*plArgCnt) >= (s4ArgCnt - 1) )
			{
				bSkipComma = TRUE;
			}
			iFuncRet = cppRepNewMacroArgInfo( (*plArgCnt), astPreArgToken, astAftArgToken );
			if( iFuncRet != COEXIT_SUCCESS )
			{
				return (iFuncRet);
			}

			iFuncRet = CppTokenGetNextToken( TRUE, TRUE );

			astPreArgToken = CUR_TOKEN_INDEX;
		}
		else
		{
			iFuncRet = CppTokenGetNextToken( FALSE, TRUE );
		}
	}

	if( iFuncRet == COEXIT_FATAL )
	{
		return (iFuncRet);
	}

	if( usPPKind != xPPTOKEN_CLOSEPAREN )
	{
		CppThrowWarning( CPP_MACRO_FORMAT_ILLEGAL,
				stCppTokenAccess.codeScp.get(CUR_TOKEN_INDEX),
				stCppTokenAccess.name.get(CUR_TOKEN_INDEX), NULL );
		return COEXIT_ERROR;
	}
	if( bVariable == TRUE && (*plArgCnt) == (s4ArgCnt - 1) )
	{
		 (*plArgCnt)++;
		iFuncRet = cppRepNewMacroArgInfo( (*plArgCnt), 0, 0 );
		if( iFuncRet != COEXIT_SUCCESS )
		{
			return (iFuncRet);
		}
	}
	/*debug,12/10/12,S*/
	iFuncRet = CppTokenGetNextToken( TRUE, FALSE );
	/*debug,12/10/12,E*/

	return (iFuncRet);
}


/************************************************************************/
/* 関 数 名 : 	cppRepTmpGetArg												*/
/* 機    能 :																*/
/* 引 き 数 : 	plArgCnt			実引数の数								*/
/*			pastStart			開始トークン								*/
/*			astEnd				終了トークン								*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_WARNING		警告終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
static S4 cppRepTmpGetArg(AST astMacroDef, AST *pastArgCnt, AST *pastStart, AST astEnd)
{
//	S4 	iRetVal;
	S4		iFuncRet;				/* 戻り値 */
	U2 	usPPKind;				/* 前処理字句種類 */
	AST 	astPreArgToken;  		/* 引数開始前処理字句 */
	AST 	astAftArgToken;			/* 引数終了前処理字句 */

	(*pastArgCnt) = -1;
//	iRetVal = COEXIT_SUCCESS;

	(*pastStart)++;
	if( (*pastStart) > astEnd )
	{
		return COEXIT_FINISHED;
	}

	/*テーブルKIND_PPTOKENの(*pastStart）行目のUSHORT_PPTOKENKIND属性を「前処理字句種類」に代入する*/
	usPPKind = stCppTokenAccess.tokenKind.get( *pastStart );

	while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
	{
		(*pastStart)++;
		if( (*pastStart) > astEnd )
		{
			return COEXIT_FINISHED;
		}
		usPPKind = stCppTokenAccess.tokenKind.get( *pastStart );
	}

	if( usPPKind != xPPTOKEN_OPENPAREN )
	{
		return COEXIT_SUCCESS;
	}

	(*pastStart)++;
	if( (*pastStart) > astEnd )
	{
		return COEXIT_FINISHED;
	}

	*pastArgCnt = 0;

	/*「引数開始前処理字句」に　(*pastStart）を代入する*/
	astPreArgToken = *pastStart;

	iFuncRet = COEXIT_SUCCESS;
	while( iFuncRet == COEXIT_SUCCESS)
	{
		/*テーブルKIND_PPTOKENの(*pastStart）行目のUSHORT_PPTOKENKIND属性を「前処理字句種類」に代入する*/
		usPPKind = stCppTokenAccess.tokenKind.get( *pastStart );

		if( usPPKind == xPPTOKEN_CLOSEPAREN )
		{
			/*「引数開始前処理字句」行目の前処理字句種類を取得*/
			usPPKind =  stCppTokenAccess.tokenKind.get( astPreArgToken );

			while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
			{
				/*「引数開始前処理字句」++*/
				astPreArgToken++;
				usPPKind =  stCppTokenAccess.tokenKind.get( astPreArgToken );
			}

			/*「引数終了前処理字句」　=　*pastStart　-　1*/
			astAftArgToken = (*pastStart) - 1;

			if( astPreArgToken <= astAftArgToken )
			{
				usPPKind =  stCppTokenAccess.tokenKind.get( astAftArgToken );
				while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
				{
					astAftArgToken--;
					if( astPreArgToken > astAftArgToken )
					{
						break;
					}
					usPPKind = stCppTokenAccess.tokenKind.get( astAftArgToken );
				}
			}

			if( astPreArgToken <= astAftArgToken )
			{
				(*pastArgCnt)++;

				iFuncRet = cppRepNewMacroArgInfo( (*pastArgCnt), astPreArgToken, astAftArgToken );
				if( iFuncRet != COEXIT_SUCCESS )
				{
					return (iFuncRet);
				}
			}
			else if( (*pastArgCnt) != 0 )
			{
				(*pastArgCnt)++;

				iFuncRet = cppRepNewMacroArgInfo( (*pastArgCnt), 0, 0 );
				if( iFuncRet != COEXIT_SUCCESS )
				{
					return (iFuncRet);
				}
			}
			usPPKind = xPPTOKEN_CLOSEPAREN;
			break;

		}
		else if( usPPKind == xPPTOKEN_OPENPAREN )
		{
			iFuncRet = cppRepTmpInsidePar( pastStart, astEnd );
		}
		else if( usPPKind == xPPTOKEN_COMMA )
		{
			/*「引数開始前処理字句」行目の前処理字句種類を取得*/
			usPPKind = stCppTokenAccess.tokenKind.get( astPreArgToken );

			while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
			{
				/*「引数開始前処理字句」++*/
				astPreArgToken++;
				usPPKind = stCppTokenAccess.tokenKind.get( astPreArgToken );
			}

			/*「引数終了前処理字句」　=　(*pastStart)　-　1*/
			astAftArgToken = (*pastStart) - 1;

			if( astPreArgToken <= astAftArgToken )
			{
				usPPKind = stCppTokenAccess.tokenKind.get( astAftArgToken );
				while( (usPPKind==xPPTOKEN_HSPACE) || (usPPKind==xPPTOKEN_VSPACE) || (usPPKind==xPPTOKEN_NEXTLINE) )
				{
					astAftArgToken--;
					if( astPreArgToken > astAftArgToken )
					{
						break;
					}
					usPPKind = stCppTokenAccess.tokenKind.get( astAftArgToken );
				}
			}

			if( astPreArgToken <= astAftArgToken )
			{
				(*pastArgCnt)++;

				iFuncRet = cppRepNewMacroArgInfo( (*pastArgCnt), astPreArgToken, astAftArgToken );
				if( iFuncRet != COEXIT_SUCCESS )
				{
					return (iFuncRet);
				}
			}
			else
			{
				(*pastArgCnt)++;

				iFuncRet = cppRepNewMacroArgInfo( (*pastArgCnt), 0, 0 );
				if( iFuncRet != COEXIT_SUCCESS )
				{
					return (iFuncRet);
				}			}

			(*pastStart)++;
			if( (*pastStart) > astEnd )
			{
				iFuncRet =  COEXIT_FINISHED;
			}
			astPreArgToken = *pastStart;

		}
		else
		{
			(*pastStart)++;
			if( (*pastStart) > astEnd )
			{
				iFuncRet =  COEXIT_FINISHED;
			}
		}
	}

	if( iFuncRet == COEXIT_FATAL )
	{
		return (iFuncRet);
	}

	if(usPPKind != xPPTOKEN_CLOSEPAREN )
	{
		CppThrowWarning( CPP_MACRO_FORMAT_ILLEGAL,
				stCppTokenAccess.codeScp.get(*pastStart),
				stCppTokenAccess.name.get(*pastStart), NULL );
		return COEXIT_ERROR;
	}

	(*pastStart)++;
	if( (*pastStart) > astEnd )
	{
		return COEXIT_FINISHED;
	}

	return COEXIT_SUCCESS;
}


/************************************************************************/
/* 関 数 名 : 	CppIsOnePPToken												*/
/* 機    能 :	二つの前処理字句が結合できるか否か判断する							*/
/* 引 き 数 : 	astPP1				トークン1									*/
/*			astPP2				トークン2									*/
/*			pusPPKind			結合できる場合、結合後の前処理字句種類を返す		*/
/* 戻 り 値 :	TRUE				結合できる									*/
/*			FALSE				結合できない								*/
/************************************************************************/
BOOL CppIsOnePPToken(AST astPP1, AST astPP2, U2 *pusPPKind)
{
	BOOL 	bRetFlg = FALSE;
	U2 	usPPKind1 = 0;
	U2  usPPKind2 = 0;
	PSZ 	pszPPName = NULL;					/*前処理字句1*/
	S4 	iPPNameLen = 0;						/*前処理字句名length*/

	/*KIND_PPTOKENのastPP1行目のUSHORT_PPTOKENKIND属性を取得*/
	usPPKind1 = stCppTokenAccess.tokenKind.get( astPP1 );

	/*KIND_PPTOKENのastPP2行目のUSHORT_PPTOKENKIND属性を取得*/
	usPPKind2 = stCppTokenAccess.tokenKind.get( astPP2 );

	switch( usPPKind1 )
	{
	case xPPTOKEN_PPNUM:
		switch( usPPKind2 )
		{
		case xPPTOKEN_PPNUM:
		case xPPTOKEN_SYM:
		case xPPTOKEN_DOT:
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_SUB:
		case xPPTOKEN_ADD:
			pszPPName = stCppTokenAccess.name.get( astPP1 );
			iPPNameLen = strlen( pszPPName );
			if(   ( ( pszPPName[iPPNameLen-1] ) == 'E' )
			   || ( ( pszPPName[iPPNameLen-1] ) == 'e' ) )
			   	{
			   		bRetFlg = TRUE;
			   	}
			else
				{
					bRetFlg = FALSE;
				}
			break;

		default:
			bRetFlg = FALSE;
			break;
		}

		if( pusPPKind != NULL )
		{
			*pusPPKind = xPPTOKEN_PPNUM;
		}
		break;

	case xPPTOKEN_SYM:
		switch( usPPKind2 )
		{
		case xPPTOKEN_SYM:
			bRetFlg = TRUE;
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_SYM;
			}
			break;

		case xPPTOKEN_PPNUM:
			pszPPName = stCppTokenAccess.name.get( astPP2 );
			while( *pszPPName != '\0' )
			{
				if(	  ( *pszPPName == '+' )
					||( *pszPPName == '-' )
					||( *pszPPName == '.' ) )
				  	{
				  		break;
				  	}
				  	pszPPName ++;
			}

			if( *pszPPName != '\0' )
			{
				bRetFlg = FALSE;
			}
			else
			{
				bRetFlg = TRUE;
			}
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_SYM;
			}
			break;

		case xPPTOKEN_STR:
		case xPPTOKEN_CHAR:
			pszPPName = stCppTokenAccess.name.get( astPP1 );
			if (strlen(pszPPName) == 1 && *pszPPName == 'L') {
				pszPPName = stCppTokenAccess.name.get( astPP2 );
				if (*pszPPName != 'L') {
					bRetFlg = TRUE;
				}else {
					bRetFlg = FALSE;
				}
			}
			if (pusPPKind != NULL) {
				*pusPPKind = usPPKind2;
					}
			break;

		default:
			bRetFlg = FALSE;
			break;
		}


		break;

	case xPPTOKEN_EQU:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_EQUEQU;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_NOT:
		switch( usPPKind2 )
		{
		case  xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_NOTEQU;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_SUB:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_SUBEQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_MORE:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_POINTERMEM;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_SUB:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_DEC;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_ADD:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_ADDEQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_ADD:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_INC;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_LSHT:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_LSHTEQU;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_LESS:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_LESSEQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_LESSEQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_LSHTEQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_LESS:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_LSHT;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_RSHT:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_RSHTEQU;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_MORE:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_MOREEQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_MOREEQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_RSHTEQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_MORE:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_RSHT;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_OR:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_OREQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_OR:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_OROR;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_AND:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_ANDEQU;
			}
			bRetFlg = TRUE;
			break;

		case xPPTOKEN_AND:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_ANDAND;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_MUL:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_MULEQU;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_DIV:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_DIVEQU;
			}
			bRetFlg = TRUE;
			break;

		default:
		 	bRetFlg = FALSE;
		 	break;
		}
		break;

	case xPPTOKEN_MOD:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
		 	if( pusPPKind != NULL )
		 	{
		 		*pusPPKind = xPPTOKEN_MODEQU;
		 	}
		 	bRetFlg = TRUE;
			break;

		default:
		 	bRetFlg = FALSE;
		 	break;
		}
		break;

	case xPPTOKEN_XOR:
		switch( usPPKind2 )
		{
		case xPPTOKEN_EQU:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_XOREQU;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	case xPPTOKEN_SHARP:
		switch( usPPKind2 )
		{
		case xPPTOKEN_SHARP:
			if( pusPPKind != NULL )
			{
				*pusPPKind = xPPTOKEN_SHARPSHARP;
			}
			bRetFlg = TRUE;
			break;

		default:
			bRetFlg = FALSE;
			break;
		}
		break;

	default:
		bRetFlg = FALSE;
		break;
	}

	return bRetFlg;
}
static S4 cppRepFileMacro(PWORKSYMCONV pstSymCtrl)
{
	AST astTemp;
	AST astNewToken;
	PSZ pszTemp;

	/* __FILE__ */
	memset(chNameBuffer, 0, sizeof(chNameBuffer));
	/* ファイルのフルパス名取得 */
	astTemp = stCppNestFileInfoAccess.getMax();
	if (astTemp < MIN_ARRAY) {
		strcpy(chNameBuffer, " ");
	}else {
		pszTemp = stCppNestFileInfoAccess.filePath.get( astTemp );
		sprintf(chNameBuffer, "\"%s\"", pszTemp);
	}

	astNewToken = CppTokenNewOne( xPPTOKEN_STR, pstSymCtrl->astCodeScope, chNameBuffer );
	if( astNewToken == 0 )
	{
		return COEXIT_FATAL;
	}

	pstSymCtrl->stDstBlock.astEnd = astNewToken;
	return COEXIT_SUCCESS;
}
static S4 cppRepLineMacro(PWORKSYMCONV pstSymCtrl)
{
	AST astTemp;
	S4 lTemp;
	AST astNewToken;

	memset(chNameBuffer, 0, sizeof(chNameBuffer));
	/* 現在の行情報を取得する */
	astTemp = stCppNestFileInfoAccess.getMax();
	if (astTemp < MIN_ARRAY) {
		lTemp = 0;
	}else {
		lTemp = stCppNestFileInfoAccess.logicLine.get( astTemp );
		lTemp -= stCppNestFileInfoAccess.physicalLine.get( astTemp );
		lTemp += stCoreCodeScpAccess.startLine.get( pstSymCtrl->astCodeScope );
	}
	sprintf(chNameBuffer, "%ld", lTemp);

	astNewToken = CppTokenNewOne( xPPTOKEN_PPNUM, pstSymCtrl->astCodeScope, chNameBuffer );
	if( astNewToken == 0 )
	{
		return COEXIT_FATAL;
	}

	pstSymCtrl->stDstBlock.astEnd = astNewToken;
	return COEXIT_SUCCESS;
}
static S4 cppRepSrcNameMacro(PWORKSYMCONV pstSymCtrl)
{
	AST astTemp;
	PSZ pszTemp;
	AST astNewToken;

	/* __BASE__ */
	memset(chNameBuffer, 0, sizeof(chNameBuffer));
	/* ファイルのファイル名取得 */
	astTemp = stCppNestFileInfoAccess.getMax();
	if (astTemp < MIN_ARRAY) {
		strcpy(chNameBuffer, " ");
	}else {
		pszTemp = stCppNestFileInfoAccess.filePath.get( astTemp );
		pszTemp = FilePickUpName(pszTemp);
		sprintf(chNameBuffer, "\"%s\"", pszTemp);
	}

	astNewToken = CppTokenNewOne( xPPTOKEN_STR, pstSymCtrl->astCodeScope, chNameBuffer );
	if( astNewToken == 0 )
	{
		return COEXIT_FATAL;
	}

	pstSymCtrl->stDstBlock.astEnd = astNewToken;
	return COEXIT_SUCCESS;
}
static S4 cppRepDataMacro(PWORKSYMCONV pstSymCtrl)
{
	time_t	tTime;
	struct tm *ptmTime;
	AST astNewToken;

	memset(chNameBuffer, 0, sizeof(chNameBuffer));
	/* 現在日付を"Apl 12 1999"ような文字列に変換 */
	tTime = time(NULL);
	ptmTime = localtime(&tTime);
	strftime(chNameBuffer, cMAXBUFFERSIZE, "%b %d %Y", ptmTime);

	/* KIND_PPTOKENに追加 */
	astNewToken = CppTokenNewOne( xPPTOKEN_STR, pstSymCtrl->astCodeScope, chNameBuffer );
	if( astNewToken == 0 )
	{
		return COEXIT_FATAL;
	}
	pstSymCtrl->stDstBlock.astEnd = astNewToken;
	return COEXIT_SUCCESS;
}
static S4 cppRepTimeMacro(PWORKSYMCONV pstSymCtrl)
{
	time_t	tTime;
	struct tm *ptmTime;
	AST astNewToken;

	memset(chNameBuffer, 0, sizeof(chNameBuffer));
	/* 現在時間を"02:12:12"のような文字列に変換 */
	tTime = time(NULL);
	ptmTime = localtime(&tTime);
	strftime(chNameBuffer, cMAXBUFFERSIZE, "%H:%M:%S", ptmTime);

	/* KIND_PPTOKENに追加 */
	astNewToken = CppTokenNewOne( xPPTOKEN_STR, pstSymCtrl->astCodeScope, chNameBuffer );
	if( astNewToken == 0 )
	{
		return COEXIT_FATAL;
	}
	pstSymCtrl->stDstBlock.astEnd = astNewToken;
	return COEXIT_SUCCESS;
}
/************************************************************************/
/* 関 数 名 : 	CppRepMacro													*/
/* 機    能 :																*/
/* 引 き 数 : 	pstSymCtrl													*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_WARNING		警告終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
S4 CppRepMacro(PWORKSYMCONV pstSymCtrl)
{
	U2	usTemp;
	AST		astTemp;
	PSZ		pszTemp;
	U2 	usKind;
	U2	usTokenKind;			/* 前処理字句の種類 */
	AST		astSRep;				/* 開始の置換要素 */
	AST		astERep;				/* 終了の置換要素 */
	AST		astRep;					/* 置換要素 */
	S2	sArgIndex;				/* 引数番号 */
	AST		astSToken;				/* 開始の前処理字句 */
	AST		astEToken;				/* 終了の前処理字句 */
	AST		astNewToken;			/* 新前処理字句 */
	AST		astLocation;			/* 位置情報 */
	BOOL	bCon = FALSE;					/* 結合フラグ */
	S4		iLength;				/* 文字数 */
	PSZ		pszTokenName;			/* 前処理字句名 */
	AST		astConToken;			/* 結合前処理字句 */
	static CHAR	chNameBuffer[cMAXBUFFERSIZE];	/* 名前バッファー */

	usKind = stCoreMacroDefInfoAccess.macroKind.get( pstSymCtrl->astMacroDefInfo );
	/* __FILE__,__LINE__,__TIME__,__DATA__,__SRC__ */
	if ((usKind & MACRO_KIND_LINE) != 0) {
		/* __LINE__ */
		return cppRepLineMacro(pstSymCtrl);

	}else if ((usKind & MACRO_KIND_FILE) != 0) {
		/* __FILE__ */
		return cppRepFileMacro(pstSymCtrl);

	}else if ((usKind & MACRO_KIND_SRC ) != 0) {

		return cppRepSrcNameMacro(pstSymCtrl);

	}else if ((usKind & MACRO_KIND_DATE) != 0) {
		/* __DATE__ */
		return cppRepDataMacro(pstSymCtrl);

	}else if ((usKind & MACRO_KIND_TIME) != 0) {
		/* __TIME__ */
		return cppRepTimeMacro(pstSymCtrl);
	}

	/* ユーザー定義マクロ */
	astSRep = stCoreMacroDefInfoAccess.startReplaceEle.get( pstSymCtrl->astMacroDefInfo );
	astERep = stCoreMacroDefInfoAccess.endReplaceEle.get ( pstSymCtrl->astMacroDefInfo );
	bCon = FALSE;
	astConToken = 0;
	/* 各置換要素を処理 */
	for (astRep = astSRep; astRep <= astERep; astRep ++) {
		if (astRep < MIN_ARRAY) {
			/* 無効の連番 */
			break;
		}

		/* 置換要素の種類より処理 */
		usKind = stCoreDefRepInfoAccess.kind.get( astRep );
		switch (usKind) {
			case EXT_PARAM:
				/* 引数 */
				bCon = FALSE;
				sArgIndex = stCoreDefRepInfoAccess.paramIdx.get( astRep ) - 1;
				sArgIndex += pstSymCtrl->stArgDstBlock.astStart;
				astSToken = stCppMcrArgInfoAccess.begin.get( sArgIndex );
				if (astSToken < MIN_ARRAY) {
					break;
				}
				/* コピー */
				astEToken = stCppMcrArgInfoAccess.end.get( sArgIndex );
				/* 展開後の位置に対応するため、引数の位置情報をコピーする */

//				astPreOldLoc = 0;
//				astPreNewLoc = 0;
				for( astTemp = astSToken; astTemp <= astEToken; astTemp++ )
				{
					FATAL_ON_FALSE(stCppTokenAccess.alloc(1));
					astSToken = stCppTokenAccess.getMax();
					FATAL_ON_FALSE(stCppTokenAccess.copy( astTemp, astSToken , 1));
					stCppTokenAccess.codeScp.set( astSToken, pstSymCtrl->astCodeScope  );
//					astOldLoc = stCppTokenAccess.codeScp.get( astTemp );
//
//					if( astPreOldLoc == astOldLoc )
//					{
//						astNewLoc = astPreNewLoc;
//					}
//					else
//					{
//						FATAL_ON_FALSE(MemTmpAlloc(KIND_LOCATION, 1));
//						astNewLoc = Mem_GetMaxbyKind(KIND_LOCATION);
//						FATAL_ON_FALSE(Mem_MoveMem(KIND_LOCATION, astOldLoc, astNewLoc , 1));
//						astPreNewLoc = astNewLoc;
//						astPreOldLoc = astOldLoc;
//					}
//					FATAL_NOT_X(astNewLoc, Mem_SetProperty_TableIndex(IDX_LOCATION, KIND_PPTOKEN, astSToken, astNewLoc ));
				}
				break;

			case EXT_SPARAM:
			case EXT_SPARAMDS:
				/* #引数　または #引数## */
				sArgIndex = stCoreDefRepInfoAccess.paramIdx.get( astRep ) - 1;
				sArgIndex += pstSymCtrl->stArgSrcBlock.astStart;
				astSToken = stCppMcrArgInfoAccess.begin.get( sArgIndex ) ;
				astEToken = stCppMcrArgInfoAccess.end.get( sArgIndex );

				if (astSToken < MIN_ARRAY) {
					break;
				}

				/* KIND_PPTOKEN追加 */
				FATAL_ON_FALSE(stCppTokenAccess.alloc(1));

				astNewToken = stCppTokenAccess.getMax();

				stCppTokenAccess.tokenKind.set( astNewToken, xPPTOKEN_STR );
				astTemp = stCppTokenAccess.codeScp.get( astSToken );
				astLocation = stCppTokenAccess.codeScp.get( astEToken );
				astLocation = stCoreCodeScpAccess.mergeCodeScp( astTemp, astLocation );
				stCppTokenAccess.codeScp.set( astNewToken, astLocation );
				/*FATAL_NOT_X(astTemp, Mem_SetProperty_TableIndex(IDX_LOCATION, KIND_PPTOKEN, astNewToken, astTemp));*/

				/* 展開後の位置に対応するため、引数の位置情報をコピーする */
				/* 開始 */
				chNameBuffer[0] = '\"';
				iLength = 1;
				/* 中身 */
				while (astSToken <= astEToken) {
					pszTokenName = stCppTokenAccess.name.get( astSToken );
					if (*pszTokenName == '\0') {
						pszTokenName = " ";
					}
					while (*pszTokenName != '\0') {
						switch (*pszTokenName) {
							case '\\':
							case '\"':
								chNameBuffer[iLength] = '\\';
								iLength ++;
								chNameBuffer[iLength] = *pszTokenName;
								iLength ++;
								break;
							default:
								chNameBuffer[iLength] = *pszTokenName;
								iLength ++;
								break;
						}

						/* バッファーいっぱいになりそう、先に書き込む */
						if (iLength >= sizeof(chNameBuffer) - 4) {
							chNameBuffer[iLength] = '\0';
							stCppTokenAccess.appendName(astNewToken, chNameBuffer);
							iLength = 0;
						}

						pszTokenName ++;
					}
					astSToken ++;
				}
				/* 終了 */
				chNameBuffer[iLength] = '\"';
				chNameBuffer[iLength + 1] = '\0';

				stCppTokenAccess.appendName(astNewToken, chNameBuffer);

				if (usKind == EXT_SPARAMDS) {
					if (bCon == TRUE && astConToken >= MIN_ARRAY) {
						CppThrowWarning( CPP_MACRO_SSTOKEN_CANNOTMERGE,
										stCppTokenAccess.codeScp.get(astNewToken),
										stCppTokenAccess.name.get(astConToken),
										NULL );
					}
					bCon = TRUE;
					astConToken = astNewToken;
				}

				break;

			case EXT_DSPARAM:
				/* 引数## */
				sArgIndex = stCoreDefRepInfoAccess.paramIdx.get( astRep ) - 1;
				sArgIndex += pstSymCtrl->stArgSrcBlock.astStart;
				astSToken = stCppMcrArgInfoAccess.begin.get( sArgIndex ) ;
				astEToken = stCppMcrArgInfoAccess.end.get( sArgIndex );
				if (astSToken < MIN_ARRAY) {
					bCon = FALSE;
				}else {
					if (bCon == TRUE && astConToken >= MIN_ARRAY) {
						if (FALSE == CppIsOnePPToken(astConToken, astSToken, &usTokenKind)) {
							CppThrowWarning( CPP_MACRO_SSTOKEN_CANNOTMERGE,
									stCppTokenAccess.codeScp.get(astSToken),
									stCppTokenAccess.name.get(astConToken),
									NULL );
						}else {
							stCppTokenAccess.tokenKind.set( astConToken, usTokenKind );
							stCppTokenAccess.codeScp.set( astConToken, pstSymCtrl->astCodeScope );
							pszTokenName = stCppTokenAccess.name.get(astSToken);
							stCppTokenAccess.appendName( astConToken, pszTokenName );
							astSToken ++;
						}
					}

					if (astSToken >= MIN_ARRAY && astSToken <= astEToken) {
						for( astTemp = astSToken; astTemp <= astEToken; astTemp++ )
						{
							FATAL_ON_FALSE(stCppTokenAccess.alloc(1));
							astSToken = stCppTokenAccess.getMax();
							FATAL_ON_FALSE(stCppTokenAccess.copy(astTemp, astSToken , 1));
						}
					}

					bCon = TRUE;
					astConToken = stCppTokenAccess.getMax();
				}

				break;

			case EXT_STRING:
				/* 引数以外 */
				/* KIND_PPTOKEN追加 */
				bCon = FALSE;
				FATAL_ON_FALSE(stCppTokenAccess.alloc(1));
				astNewToken = stCppTokenAccess.getMax();

				usTemp = stCoreDefRepInfoAccess.ppTokenKind.get( astRep );
				stCppTokenAccess.tokenKind.set( astNewToken, usTemp );
				stCppTokenAccess.codeScp.set(astNewToken, pstSymCtrl->astCodeScope );

				pszTemp = stCoreDefRepInfoAccess.name.get( astRep );
				stCppTokenAccess.name.set( astNewToken, pszTemp );
				break;

			case EXT_DSSTRING:
				/* 引数以外## */

				/* KIND_PPTOKEN 追加 */
				FATAL_ON_FALSE(stCppTokenAccess.alloc(1));
				astNewToken = stCppTokenAccess.getMax();

				usTemp = stCoreDefRepInfoAccess.ppTokenKind.get( astRep );
				stCppTokenAccess.tokenKind.set( astNewToken, usTemp );
				stCppTokenAccess.codeScp.set(astNewToken, pstSymCtrl->astCodeScope );

				pszTemp = stCoreDefRepInfoAccess.name.get( astRep );
				stCppTokenAccess.name.set( astNewToken, pszTemp );

				if (bCon == TRUE && astConToken >= MIN_ARRAY) {
					if (FALSE == CppIsOnePPToken(astConToken, astNewToken, &usTokenKind)) {
						/* エラーコード3306を警告する */
						CppThrowWarning( CPP_MACRO_SSTOKEN_CANNOTMERGE,
										stCppTokenAccess.codeScp.get(astNewToken),
										stCppTokenAccess.name.get(astConToken),
										NULL );
					}else {
						stCppTokenAccess.tokenKind.set( astConToken, usTokenKind );
						pszTokenName = stCppTokenAccess.name.get( astNewToken );
						stCppTokenAccess.appendName( astConToken, pszTokenName );
						FATAL_ON_FALSE(stCppTokenAccess.alloc(-1));
						astNewToken = 0;
					}
				}
				bCon = TRUE;
				astConToken = astNewToken == 0? astConToken:astNewToken;

				break;
			default:
				bCon = FALSE;
				break;
		}
	}

	/* 後処理 */
	astNewToken = stCppTokenAccess.getMax();
	if (astNewToken >= pstSymCtrl->stDstBlock.astStart) {
		pstSymCtrl->stDstBlock.astEnd = astNewToken;
		for( astNewToken = pstSymCtrl->stDstBlock.astStart;
		astNewToken <= pstSymCtrl->stDstBlock.astEnd;
		astNewToken ++ ){
			if( stCppTokenAccess.recFlag.get( astNewToken ) != ON ){
				stCppTokenAccess.macroExtStack.set( astNewToken, pstSymCtrl->astTmpMacroCall );
			}
		}
	}else {
		pstSymCtrl->stDstBlock.astEnd = 0;
		pstSymCtrl->stDstBlock.astStart = 0;
	}

	return COEXIT_SUCCESS;
}


/************************************************************************/
/* 関 数 名 : 	CppRepNewCtrl												*/
/* 機    能 :																*/
/* 引 き 数 : 	astPP														*/
/*			astMacroDef													*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_WARNING		警告終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
S4 CppRepNewCtrl(AST astPP, AST astMacroDef)
{
	AST		astTemp;
	S4	lTemp;

	WORKSYMCONV stRepInfo;				/* 置換管理情報 */
	AST		astPreArgInfo;				/* 前回の実引数情報 */
	AST		astRepTmpInfo;				/* 置き換え中間情報 */
	AST		astNewRepTmpInfo;			/* 新置き換え中間情報 */
	AST		astMacroCall;				/* マクロ呼び出し情報 */
	AST		astScope1;
	AST		astScope2;				/* 位置情報 */
	S4	lArgCnt;					/* 実引数の数 */
	S4		nRet;						/* 戻り値 */

	AST		astBRepArg;					/* 置換前の実引数情報 */
	AST		astARepArg;					/* 置換後の実引数情報 */
	AST		astSTokenBRep;				/* 置換前の開始の前処理字句 */
	AST		astETokenBRep;				/* 置換前の終了の前処理字句 */
	AST		astSTokenARep;				/* 置換後の開始の前処理字句 */
	AST		astETokenARep;				/* 置換後の終了の前処理字句 */
	S4	lTokenCnt;					/* 前処理字句の数 */

	/* 初期化 */
	memset(&stRepInfo, 0, sizeof(WORKSYMCONV));
	astPreArgInfo = stCppMcrArgInfoAccess.getMax();

	/* 再帰マクロ確認 */
	astRepTmpInfo = stCppTokenAccess.macroExtStack.get( astPP );
	while (astRepTmpInfo != 0) {
		astTemp = stCppMcrExtStkAccess.macroInfo.get( astRepTmpInfo );
		if (astTemp == astMacroDef) {
			break;
		}
		astRepTmpInfo = stCppMcrExtStkAccess.inheritMcr.get( astRepTmpInfo );
	}
	if (astRepTmpInfo != 0) {
		/* 再帰マクロ */
		stCppTokenAccess.recFlag.set( astPP, ON );
		return COEXIT_SUCCESS;
	}

	/* マクロ呼び出し箇所を呼び込む */
	if (MACRO_FUNC == stCoreMacroDefInfoAccess.macroKind.get( astMacroDef ) ){
		nRet = cppRepGetArg(astMacroDef,&lArgCnt);
		if (nRet == COEXIT_FATAL) {
			return (nRet);
		}else if (nRet == COEXIT_ERROR) {
			return (nRet);
		}

		if (lArgCnt == -1) {
			stCppTokenAccess.recFlag.set( astPP, ON );
			return CppTokenResetCurrOne(astPP);
		}else {
			if (lArgCnt != stCoreMacroDefInfoAccess.paramNum.get( astMacroDef ) ) {
				AST stDirInfo;
				/* エラーコードCPP_MACRO_ARGNUM_DIFFを警告する */
				CppThrowWarning( CPP_MACRO_ARGNUM_DIFF,
								stCppTokenAccess.codeScp.get(astPP),
								stCppTokenAccess.name.get(astPP),
								NULL );
				stDirInfo = stCoreMacroDefInfoAccess.directiveInfo.get( astMacroDef );
				CppThrowWarning( CPP_MACRO_ARGNUM_DIFF_DEFLOC,
								stCoreDirectiveInfoAccess.locScope.get(stDirInfo),
								stCppTokenAccess.name.get(astPP),
								NULL );
				return COEXIT_ERROR;
			}
		}
	}else {
		nRet = CppTokenGetNextToken( TRUE, FALSE);
		lArgCnt = 0;
	}

	/* 位置情報取得 */
	astScope1 = stCppTokenAccess.codeScp.get( astPP );
	astScope2 = stCppTokenAccess.codeScp.get( CUR_TOKEN_INDEX - 1 );

	astMacroCall = stCoreCodeScpAccess.mergeCodeScp( astScope1, astScope2 );
	if( astMacroCall == 0 )
	{
		astMacroCall = astScope1;
	}

	/* 置換履歴設定 */
	/* KIND_TEMPMACROCALL追加 */
	FATAL_ON_FALSE( stCppMcrExtStkAccess.alloc(1) );
	astNewRepTmpInfo = stCppMcrExtStkAccess.getMax();

	stCppMcrExtStkAccess.macroInfo.set( astNewRepTmpInfo, astMacroDef );

	astRepTmpInfo = stCppTokenAccess.macroExtStack.get( astPP );
	if (astRepTmpInfo > 0) {
		stCppMcrExtStkAccess.inheritMcr.set( astNewRepTmpInfo, astRepTmpInfo );
	}
	stCppTokenAccess.macroExtStack.set(astPP, astNewRepTmpInfo);

	/* 置換管理情報作成 */

	if (lArgCnt > 0) {
		stRepInfo.stArgSrcBlock.astStart = astPreArgInfo + 1;
		stRepInfo.stArgSrcBlock.astEnd = lArgCnt + astPreArgInfo ;
	}else{
		stRepInfo.stArgSrcBlock.astStart = 0;
		stRepInfo.stArgSrcBlock.astEnd = 0;
	}
	stRepInfo.stArgDstBlock.astStart = 0;
	stRepInfo.stArgDstBlock.astEnd = 0;

	stRepInfo.stSrcBlock.astStart = astPP;
	stRepInfo.stSrcBlock.astEnd = CUR_TOKEN_INDEX - 1;
	if( stRepInfo.stSrcBlock.astEnd < stRepInfo.stSrcBlock.astStart ){
		stRepInfo.stSrcBlock.astEnd = stRepInfo.stSrcBlock.astStart;
	}
	stRepInfo.astMacroDefInfo = astMacroDef;
	stRepInfo.astTmpMacroCall = astNewRepTmpInfo;
	stRepInfo.astCodeScope = astMacroCall;

	/* replace the arguments */
	astBRepArg = stRepInfo.stArgSrcBlock.astStart;
	for (; astBRepArg != 0 && astBRepArg <= stRepInfo.stArgSrcBlock.astEnd; astBRepArg++  ) {
		astSTokenBRep = stCppMcrArgInfoAccess.begin.get( astBRepArg );
		astETokenBRep = stCppMcrArgInfoAccess.end.get( astBRepArg );

		/* KIND_MACROARGINFO追加 */
		FATAL_ON_FALSE(stCppMcrArgInfoAccess.alloc(1));
		astARepArg = stCppMcrArgInfoAccess.getMax();
		lTemp = stCppMcrArgInfoAccess.index.get( astBRepArg );
		stCppMcrArgInfoAccess.index.set( astARepArg, lTemp );

		if( stRepInfo.stArgDstBlock.astStart == 0 ){
			stRepInfo.stArgDstBlock.astStart = astARepArg;
		}
		stRepInfo.stArgDstBlock.astEnd = astARepArg;

		if (astSTokenBRep < MIN_ARRAY) {
			if (stCoreMacroDefInfoAccess.bVariableParam.get( astMacroDef ) ){
				if( stCppMcrArgInfoAccess.index.get( astBRepArg )
					== stCoreMacroDefInfoAccess.paramNum.get( astMacroDef )	){
					continue;
				}
			}
			CppThrowWarning( CPP_MACRO_BLANK_ARG,
							stCppTokenAccess.codeScp.get(astPP),
							stCppTokenAccess.name.get(astPP),
							NULL );
			continue;
		}
		lTokenCnt = astETokenBRep - astSTokenBRep + 1;

		astSTokenARep = stCppTokenAccess.getMax();
		astSTokenARep ++;

		/* KIND_PPTOKEN追加 */
		stCppTokenAccess.alloc(lTokenCnt );
		astETokenARep = stCppTokenAccess.getMax();

		FATAL_ON_FALSE(stCppTokenAccess.copy( astSTokenBRep, astSTokenARep, lTokenCnt));

		lTemp = (S4)CppRepTmpToken(astSTokenARep, &astETokenARep);
		if (lTemp != COEXIT_SUCCESS) {
			return ((S4)lTemp);
		}
		stCppMcrArgInfoAccess.begin.set( astARepArg, astSTokenARep );
		stCppMcrArgInfoAccess.end.set(astARepArg, astETokenARep);

	}
	stRepInfo.stDstBlock.astStart = stCppTokenAccess.getMax() + 1;
	stRepInfo.stDstBlock.astEnd = 0;
	/* 置換 */
	lTemp = (S4)CppRepMacro(&stRepInfo);
	if (lTemp != COEXIT_SUCCESS) {
		return ((S4)lTemp);
	}
	lTemp = CppTokenDeleteTokensBeforeCurr( astPP );
	if (lTemp != COEXIT_SUCCESS) {
		return ((S4)lTemp);
	}
	if( stRepInfo.stDstBlock.astStart <= stRepInfo.stDstBlock.astEnd ){
		lTemp = CppTokenMoveEndTokensToPrev( stRepInfo.stDstBlock.astStart,
				stRepInfo.stDstBlock.astEnd - stRepInfo.stDstBlock.astStart + 1 );
		if (lTemp != COEXIT_SUCCESS) {
			return ((S4)lTemp);
		}
	}

	/* 置換後不要になったPPTOKENの削除 */
	lTokenCnt = stCppTokenAccess.getMax() - CppTokenGetLastOne();
	FATAL_ON_FALSE(stCppTokenAccess.alloc(-lTokenCnt));

	/* 引数情報の削除 */
	lTokenCnt = stCppMcrArgInfoAccess.getMax() - astPreArgInfo;
	FATAL_ON_FALSE(stCppMcrArgInfoAccess.alloc(-lTokenCnt));

	return COEXIT_SUCCESS;
}


/************************************************************************/
/* 関 数 名 : 	CppRepTmpNewCtrl											*/
/* 機    能 :																*/
/* 引 き 数 : 	astPP														*/
/*			pastEnd														*/
/*			astMacroDef													*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_WARNING		警告終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
S4 CppRepTmpNewCtrl(AST astPP, AST* pastEnd, AST astMacroDef)
{
	S4 			iRetVal;			/*戻り値*/
	S4				iRepRetVal;			/* 関数戻り値 */
	S2 			sTmp;
	U2			usTmp;
	AST 			astTmp;
	WORKSYMCONV 	stRepManInfo;		/*置換管理情報*/
	AST 			astArgCnt;			/*前回の実引数情報*/
	AST				astTmpMacro;		/*置換中間情報*/
	AST				astNewTmpMacro;		/*新置換中間情報*/
	AST 			astMacroCallInfo;	/*マクロ呼び出し情報*/
	AST				astPPTokenLoc;		/*前処理字句位置*/
	AST				astPPTokenLoc2;		/*前処理字句位置2*/
	AST				astNowPPToken=astPP;		/*現在の前処理字句*/
	AST				astArgNum;			/*実引数の数*/
	AST				astArgPreRep;		/*置換前の実引数情報*/
	AST				astArgAftRep;		/*置換後の実引数情報*/
	AST				astStaTokenPreRep;  /*置換前の開始の前処理字句*/
	AST				astEndTokenPreRep;  /*置換前の終了の前処理字句*/
	AST				astPPTokenNum;		/*前処理字句の数*/
	AST				astStaTokenAftRep;  /*置換後の開始の前処理字句*/
	AST				astEndTokenAftRep;	/*置換後の終了の前処理字句*/

	/*置換管理情報,前回の実引数情報を初期化*/
	memset(&stRepManInfo,0,sizeof(WORKSYMCONV));
	astArgCnt = stCppMcrArgInfoAccess.getMax();

	/*「置換中間情報」　に　テーブルKIND_PPTOKENのastPP行目のIDX_TMPMACROCALL属性を設定する*/
	astTmpMacro = stCppTokenAccess.macroExtStack.get(astPP);

	/*while 「置換中間情報」　 != 0 */
	while( astTmpMacro != 0 )
	{
		/*if  テーブルKIND_TMPMACROCALLの「置換中間情報」行目のIDX_MACRODEFINFO属性　==　astMacroDef*/
		astTmp = stCppMcrExtStkAccess.macroInfo.get( astTmpMacro );
		if( astTmp == astMacroDef )
		{
			break;
		}

		/*テーブルKIND_TMPMACROCALLの「置換中間情報」行目のIDX_TMPMACROCALL属性を　「置換中間情報」に設定する*/
		astTmpMacro = stCppMcrExtStkAccess.inheritMcr.get( astTmpMacro );
	}

	/*if 「置換中間情報」 != 0*/
	if( astTmpMacro != 0 )
	{
		/*テーブルKIND_PPTOKENのastPP行目のUSHORT_RECMACRO属性　に　ON　を設定する*/
		stCppTokenAccess.recFlag.set( astPP, ON );
		return COEXIT_SUCCESS;
	}

	/*if  テーブルKIND_MACRODEFINFOのastMacroDef行目のUSHORT_MACROKIND属性　==　MACRO_FUNC*/
	usTmp = stCoreMacroDefInfoAccess.macroKind.get( astMacroDef );
	if( usTmp == MACRO_FUNC )
	{
		/*astPPを「現在の前処理字句」に代入する*/
		astNowPPToken = astPP;

		/*「戻り値」　=　cppRepTmpGetArg（　&「実引数の数」,  &「現在の前処理字句」, * pastEnd　)*/
		iRepRetVal = cppRepTmpGetArg(astMacroDef,&astArgNum, &astNowPPToken, *pastEnd );
		if( (iRepRetVal == COEXIT_FATAL) || (iRepRetVal == COEXIT_ERROR) )
		{
			return (iRepRetVal);
		}

		if( astArgNum == -1 )
		{
			/*テーブルKIND_PPTOKENのastPP行目のUSHORT_RECMACRO属性　に　ON　を設定する*/
			stCppTokenAccess.recFlag.set( astPP, ON );
			return COEXIT_SUCCESS;
		}

		/*  */
		sTmp = stCoreMacroDefInfoAccess.paramNum.get( astMacroDef );
		if( sTmp != astArgNum )
		{
			AST stDirInfo;
			CppThrowWarning( CPP_MACRO_ARGNUM_DIFF,
							stCppTokenAccess.codeScp.get(astPP),
							stCppTokenAccess.name.get(astPP),
							NULL );
			stDirInfo = stCoreMacroDefInfoAccess.directiveInfo.get( astMacroDef );
			CppThrowWarning( CPP_MACRO_ARGNUM_DIFF_DEFLOC,
							stCoreDirectiveInfoAccess.locScope.get(stDirInfo),
							stCppTokenAccess.name.get(astPP),
							NULL );
			return COEXIT_ERROR;
		}
	}
	else
	{
		/*astPP+1を「現在の前処理字句」に代入する*/
		if (astPP == *pastEnd) {
			iRepRetVal = COEXIT_FINISHED;
		}else {
			iRepRetVal = COEXIT_SUCCESS;
			astNowPPToken = astPP + 1;
		}
		astArgNum = 0;
	}


	/*「マクロ呼び出し情報」　=　0*/
	astMacroCallInfo =0;

	/*「前処理字句位置」　に　テーブルKIND_PPTOKENのastPP行目のIDX_LOCATION属性を設定する*/
	astPPTokenLoc = stCppTokenAccess.codeScp.get( astPP );
	astPPTokenLoc2 = stCppTokenAccess.codeScp.get( astNowPPToken - 1 );
	astMacroCallInfo = stCoreCodeScpAccess.mergeCodeScp( astPPTokenLoc, astPPTokenLoc2 );
	if( astMacroCallInfo == 0 ){
		astMacroCallInfo = astPPTokenLoc;
	}

	/* KIND_TEMPMACROCALL追加 */
	FATAL_ON_FALSE( stCppMcrExtStkAccess.alloc(1) );
	astNewTmpMacro = stCppMcrExtStkAccess.getMax();

	stCppMcrExtStkAccess.macroInfo.set( astNewTmpMacro, astMacroDef );
	/*  */
	stCppMcrExtStkAccess.macroInfo.set( astNewTmpMacro, astMacroDef );

	/*「置換中間情報」　に　テーブルKIND_PPTOKENのastPP行目のIDX_TMPMACROCALL属性を設定する*/
	astTmpMacro = stCppTokenAccess.macroExtStack.get( astPP );

	if( astTmpMacro > 0 )
	{
		/*テーブルKIND_TMPMACROCALLの「新置換中間情報」行目のIDX_TMPMACROCALL属性に　「置換中間情報」　を設定する*/
		stCppMcrExtStkAccess.inheritMcr.set( astNewTmpMacro, astTmpMacro );
	}
	stCppTokenAccess.macroExtStack.set( astPP, astNewTmpMacro );



	if( astArgNum > 0 )
	{
		/*「置換管理情報」のstArgSrcBlockメンバーのastStartメンバーに　「前回の実引数情報」+1　を設定する*/
		stRepManInfo.stArgSrcBlock.astStart = astArgCnt + 1;

		/*「置換管理情報」のstArgSrcBlockメンバーのulSizeメンバーに　「実引数の数」　を設定する*/
		stRepManInfo.stArgSrcBlock.astEnd = astArgCnt + astArgNum;
	}else{
		/*「置換管理情報」のstArgSrcBlockメンバーのastStartメンバーに　「前回の実引数情報」+1　を設定する*/
		stRepManInfo.stArgSrcBlock.astStart = 0;

		/*「置換管理情報」のstArgSrcBlockメンバーのulSizeメンバーに　「実引数の数」　を設定する*/
		stRepManInfo.stArgSrcBlock.astEnd = 0;
	}
	/*「置換管理情報」のstArgDstBlockメンバーのastStartメンバーに　「今回の実引数情報」+1　を設定する*/
	stRepManInfo.stArgDstBlock.astStart = 0;

	/*「置換管理情報」のstArgDstBlockメンバーのulSizeメンバーに　「実引数の数」　を設定する*/
	stRepManInfo.stArgDstBlock.astEnd = 0;

	/*「置換管理情報」のstSrcBlockメンバーのastStartメンバーに　astPP　を設定する*/
	stRepManInfo.stSrcBlock.astStart = astPP;

	/*「置換管理情報」のstSrcBlockメンバーのulSizeメンバーに　「現在の前処理字句」 - astPP　を設定する*/
	stRepManInfo.stSrcBlock.astEnd = astNowPPToken - 1;
	if( stRepManInfo.stSrcBlock.astEnd < stRepManInfo.stSrcBlock.astStart ){
		stRepManInfo.stSrcBlock.astEnd = stRepManInfo.stSrcBlock.astStart;
	}

	/*「置換管理情報」のastMacroDefInfoメンバーに　astMacroDef　を設定する*/
	stRepManInfo.astMacroDefInfo = astMacroDef;

	/*「置換管理情報」のastTmpMacroCallメンバーに　「新置換中間情報」　を設定する*/
	stRepManInfo.astTmpMacroCall = astNewTmpMacro;

	/*「置換管理情報」のastLocメンバーに　「位置情報」　を設定する*/
	stRepManInfo.astCodeScope = astMacroCallInfo;

	astArgPreRep = stRepManInfo.stArgSrcBlock.astStart ;
	/*for  0　≦　「カウンタ」　<　「置換管理情報」のstArgSrcBlockメンバーのulSizeメンバー*/
	for( ; astArgPreRep > 0 && astArgPreRep <= stRepManInfo.stArgSrcBlock.astEnd; astArgPreRep++ )
	{

		/*「置換前の開始の前処理字句」に　テーブルKIND_MACROARGINFOの「置換前の実引数情報」行目のIDX_STARTPPTOKEN属性を代入する*/
		astStaTokenPreRep = stCppMcrArgInfoAccess.begin.get(astArgPreRep);

		/*「置換前の終了の前処理字句」に　テーブルKIND_MACROARGINFOの「置換前の実引数情報」行目のIDX_ENDPPTOKEN属性を代入する*/
		astEndTokenPreRep = stCppMcrArgInfoAccess.end.get(astArgPreRep);

		/*「前処理字句の数」に　「終了の前処理字句」　-　「開始の前処理字句」　＋　1　を設定する*/
		astPPTokenNum = (astEndTokenPreRep - astStaTokenPreRep + 1);

		/*テーブルKIND_MACROARGINFOに1行を追加する*/
		FATAL_ON_FALSE(stCppMcrArgInfoAccess.alloc(1));

		astArgAftRep = stCppMcrArgInfoAccess.getMax();
		/*テーブルKIND_MACROARGINFOの「置換前の実引数情報」行目のLONG_ARGINDEX属性を取得*/
		astTmp = stCppMcrArgInfoAccess.index.get( astArgPreRep );

		/*取得した値をテーブルKIND_MACROARGINFOの「置換後の実引数情報」行目のLONG_ARGINDEX属性に設定*/
		stCppMcrArgInfoAccess.index.set(astArgAftRep, astTmp);

		if( stRepManInfo.stArgDstBlock.astStart == 0 ){
			stRepManInfo.stArgDstBlock.astStart = astArgAftRep;
		}
		stRepManInfo.stArgDstBlock.astEnd = astArgAftRep;

		/*if  「置換前の開始の前処理字句」 < MIN_ARRAY*/
		if( astStaTokenPreRep < MIN_ARRAY )
		{
			CppThrowWarning( CPP_MACRO_BLANK_ARG,
							stCppTokenAccess.codeScp.get(astPP),
							stCppTokenAccess.name.get(astPP),
							NULL );
			continue;
		}

		/*テーブルKIND_PPTOKENの行の総数を取得し、「置換後の開始の前処理字句」に代入する*/
		astStaTokenAftRep = stCppTokenAccess.getMax() + 1;

		/*テーブルKIND_PPTOKENに「前処理字句の数」行を追加する*/
		FATAL_ON_FALSE(stCppTokenAccess.alloc( astPPTokenNum ));

		/*テーブルKIND_PPTOKENの行の総数を取得し、「置換後の終了の前処理字句」に設定する*/
		astEndTokenAftRep = stCppTokenAccess.getMax();

		/*Mem_MoveMem(　KIND_PPTOKEN, 「置換前の開始の前処理字句」, 「置換後の開始の前処理字句」,　「前処理字句の数」　）*/
		iRetVal = stCppTokenAccess.copy( astStaTokenPreRep, astStaTokenAftRep, astPPTokenNum );
		if( iRetVal == FALSE )
		{
			return (COEXIT_FATAL);
		}

		/*CppRepTmpToken（　&「置換後の開始の前処理字句」,　&「置換後の終了の前処理字句」）*/
		iRetVal = CppRepTmpToken( astStaTokenAftRep, &astEndTokenAftRep);
		if( iRetVal != COEXIT_SUCCESS )
		{
			return (iRetVal);
		}

		/*テーブルKIND_MACROARGINFOの「置換後の実引数情報」行目のIDX_STARTPPTOKEN属性に　「置換後の開始の前処理字句」　　を設定する*/
		stCppMcrArgInfoAccess.begin.set(astArgAftRep, astStaTokenAftRep);

		/*テーブルKIND_MACROARGINFOの「置換後の実引数情報」行目のIDX_ENDPPTOKEN属性に　「置換後の終了の前処理字句」　　を設定する*/
		stCppMcrArgInfoAccess.end.set(astArgAftRep, astEndTokenAftRep);

	}

	/*「置換管理情報」のstDstBlockメンバーのastStart メンバー　に　テーブルKIND_PPTOKENの行の総数　+　1　を設定する*/
	stRepManInfo.stDstBlock.astStart = stCppTokenAccess.getMax() + 1 ;

	/*CppRepMacro(&「置換管理情報」）*/
	iRetVal = CppRepMacro( &stRepManInfo );
	if (iRetVal == COEXIT_FATAL)
	{
		return (iRetVal);
	}

	if( *pastEnd > stRepManInfo.stSrcBlock.astEnd )
	{
		/*「前処理字句の数」 = *pastEnd - 「置換管理情報」のstSrcBlockメンバーのastStart メンバー
		 * - 「置換管理情報」のstSrcBlockメンバーのulSize メンバー　+ 1*/
		 astPPTokenNum = *pastEnd - stRepManInfo.stSrcBlock.astEnd;
	}
	else
	{
		/*「前処理字句の数」 = ０*/
		astPPTokenNum = 0;
	}

	if( astPPTokenNum > 0 )
	{
		/* 「置換前の開始の前処理字句」　に　( 「置換管理情報」のstSrcBlockメンバーのastStart メンバー
		 * + 「置換管理情報」のstSrcBlockメンバーのulSize メンバー)を設定する*/
		 astStaTokenPreRep = stRepManInfo.stSrcBlock.astEnd + 1;

		 /*「置換後の開始の前処理字句」　に　テーブルKIND_PPTOKENの行の総数　+　1　を設定する*/
		 astStaTokenAftRep = stCppTokenAccess.getMax() + 1;

		 /*テーブルKIND_PPTOKENに「前処理字句の数」行を追加する*/
		 FATAL_ON_FALSE(stCppTokenAccess.alloc( astPPTokenNum ));

		/*Mem_MoveMem(　KIND_PPTOKEN, 「置換前の開始の前処理字句」, 「置換後の開始の前処理字句」,
		 * 「前処理字句の数」　）
		 * 戻り値を保存 */
		 iRetVal = stCppTokenAccess.copy( astStaTokenPreRep, astStaTokenAftRep, astPPTokenNum );
		 if( iRetVal == FALSE )
		 {
	 		return (COEXIT_FATAL);
	  	 }
	}

	/*「前処理字句の数」　=　　テーブルKIND_PPTOKENの行の総数　- 「置換管理情報」のstDstBlockメンバーのastStart メンバー　+　1*/
  	astPPTokenNum = stCppTokenAccess.getMax() -  stRepManInfo.stDstBlock.astStart + 1;

  	if( astPPTokenNum > 0 )
	{
  		/*Mem_MoveMem(　KIND_PPTOKEN, 「置換管理情報」のstDstBlockメンバーのastStart メンバー,  astPP,　「前処理字句の数」　）*/
  		iRetVal = stCppTokenAccess.copy( stRepManInfo.stDstBlock.astStart, astPP, astPPTokenNum);
  	 	if( iRetVal == FALSE )
	 	{
 			return (COEXIT_FATAL);
  	 	}
  	}

  	/*「前処理字句の数」　=　テーブルKIND_PPTOKENの行の総数　-　（astPP　+　「前処理字句の数」　-　1）*/
  	astPPTokenNum = stCppTokenAccess.getMax() - ( astPP + astPPTokenNum -1 );

  	/*テーブルKIND_PPTOKENに「前処理字句の数」行を削除する*/
  	FATAL_ON_FALSE(stCppTokenAccess.alloc( -astPPTokenNum ));

  	/*テーブルKIND_MACROARGINFOから　（　テーブルKIND_MACROARGINFOの行の総数　-　「前回の実引数情報」　）行を削除する*/
  	astTmp = stCppMcrArgInfoAccess.getMax() - astArgCnt;
  	FATAL_ON_FALSE(stCppMcrArgInfoAccess.alloc(  -astTmp ));

  	/**pastEnd　=　テーブルKIND_PPTOKENの行の総数*/
  	*pastEnd = stCppTokenAccess.getMax();

	return (COEXIT_SUCCESS);
}


/************************************************************************/
/* 関 数 名 : 	CppRepOutputToken											*/
/* 機    能 :	マクロ置換メイン													*/
/* 引 き 数 : 	astPPToken			出力トークン								*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
S4 CppRepOutputToken( AST astPPToken )
{
	U2	usTokenKind;
	AST		astNewPPTokenList;
	AST		astLocation;
	PSZ		pszTokenName;


	/* 空白、改行、及び識別できない符号は出力しない */
	usTokenKind = stCppTokenAccess.tokenKind.get( astPPToken );
	if (usTokenKind == xPPTOKEN_NEXTLINE ||
		usTokenKind == xPPTOKEN_VSPACE ||
		usTokenKind == xPPTOKEN_HSPACE ||
		usTokenKind == xPPTOKEN_OTHER) {
		/* 出力しない */
		return COEXIT_SUCCESS;
	}

	/* PPTOKENLIST追加 */
	FATAL_ON_FALSE(stCorePPTokenListAccess.alloc(1));
	astNewPPTokenList = stCorePPTokenListAccess.getMax();

	/* PPTOKENLIST設定 */
	stCorePPTokenListAccess.ppTokenKind.set(astNewPPTokenList, usTokenKind);

	astLocation = stCppTokenAccess.codeScp.get( astPPToken );
	stCorePPTokenListAccess.codeScope.set(astNewPPTokenList, astLocation);

	pszTokenName = stCppTokenAccess.name.get( astPPToken );
	if( pszTokenName[0] != '\0' )
	{
		stCorePPTokenListAccess.name.set( astNewPPTokenList, pszTokenName );
	}
	return COEXIT_SUCCESS;
}

/************************************************************************/
/* 関 数 名 : 	CppRepMain													*/
/* 機    能 :	マクロ置換メイン													*/
/* 引 き 数 : 	なし															*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_WARNING		警告終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
S4 CppRepMain(void)
{
	U2	usTokenKind;
	U2	usRecMacro;
	PSZ		pszTokenName;
	BOOL	bSearchValue;
	AST		astMacroDef;
	U4	ulDefined;
	S4		nRet = COEXIT_SUCCESS;
	AST     astStartPPTokenList = stCorePPTokenListAccess.getMax();
	AST   astDisableMcr;
	AST   astCntDisable;
	PSZ   pszMacro;
	BOOL	bMacroCall = FALSE;

	/* トークンずつ処理する */
	while (nRet == COEXIT_SUCCESS) {
		usTokenKind = stCppTokenAccess.tokenKind.get( CUR_TOKEN_INDEX );
		usRecMacro = stCppTokenAccess.recFlag.get( CUR_TOKEN_INDEX );

		if (usTokenKind != xPPTOKEN_SYM) {
			/* トークンはSYMBOL以外の場合、直接に出力 */
			FATAL_ON_FATAL(CppRepOutputToken(CUR_TOKEN_INDEX));
		}else if (usRecMacro == ON) {
			/* 再帰マクロの場合、直接に出力 */
			FATAL_ON_FATAL(CppRepOutputToken(CUR_TOKEN_INDEX));
		}else {
			/* 名前で検索 */
			pszTokenName = stCppTokenAccess.name.get( CUR_TOKEN_INDEX );
			bSearchValue = CppDefSearchMacro(pszTokenName, &astMacroDef);
			if (bSearchValue == TRUE) {
				astDisableMcr = stCppDisableMacroAccess.getMax();
				for( astCntDisable = MIN_ARRAY; astCntDisable <= astDisableMcr; astCntDisable ++ )
				{
					pszMacro = stCppDisableMacroAccess.name.get( astCntDisable );
					if( 0 == strcmp( pszMacro, pszTokenName ) )
					{
						bSearchValue = FALSE;
						break;
					}
				}
			}
			if (astMacroDef == 0 || bSearchValue == FALSE) {
				/* 見つかりません、マクロではないので出力 */
				FATAL_ON_FATAL(CppRepOutputToken(CUR_TOKEN_INDEX));
			}else {
				/* マクロです */
				ulDefined = stCoreMacroDefInfoAccess.bValid.get( astMacroDef );
				if (ulDefined == FALSE) {
					/* マクロだが、定義していない。出力する。 */
					FATAL_ON_FATAL(CppRepOutputToken(CUR_TOKEN_INDEX));
				}else {
					/* 置換する */
					bMacroCall = TRUE;
					nRet = CppRepNewCtrl(CUR_TOKEN_INDEX, astMacroDef);
					if (nRet != COEXIT_SUCCESS) {
						break;
					}
					if (CppTokenIsFinished()) {
						nRet = COEXIT_FINISHED;
					}
					continue;
				}
			}
		}

		/* 次 */
		nRet = CppTokenGetNextToken(TRUE, FALSE);
	}

	/* 結果チェック */
	if (nRet == COEXIT_FINISHED) {
		nRet = COEXIT_SUCCESS;
	}
	if( stCoreEnvInfo.ucCppResult && nRet == COEXIT_SUCCESS )
	{
		nRet = CppResultOutput( astStartPPTokenList + 1, bMacroCall );
	}

	/* メモリクリア */
	FATAL_ON_FATAL(CppTokensDelAll());
	stCppDisableMacroAccess.clear();

	return (nRet);
}


/************************************************************************/
/* 関 数 名 : 	CppRepTmpToken												*/
/* 機    能 :	マクロ置き換えTMP												*/
/* 引 き 数 : 	pastStart			開始トークン								*/
/*			pastEnd				終了トークン								*/
/* 戻 り 値 :	COEXIT_SUCCESS		正常終了									*/
/*			COEXIT_WARNING		警告終了									*/
/*			COEXIT_ERROR		コンパイルエラー								*/
/*			COEXIT_FATAL		致命エラー									*/
/************************************************************************/
S4 CppRepTmpToken(AST astStart, AST* pastEnd)
{
	U2	usTokenKind;
	U2	usRecMacro;
	PSZ		pszTokenName;
	S4		iSearchValue;
	AST		astMacroDef;
	U4	ulDefined;
	S4		nRet;

	/* トークンずつ処理 */
	while (astStart <= *pastEnd) {

		usTokenKind = stCppTokenAccess.tokenKind.get( astStart );
		usRecMacro =  stCppTokenAccess.recFlag.get( astStart );

		if (usTokenKind != xPPTOKEN_SYM) {
			/* SYMBOLではない */
			astStart ++;
		}else if (usRecMacro == ON) {
			/* 再帰マクロ */
			astStart ++;
		}else {
			pszTokenName = stCppTokenAccess.name.get( astStart );
			iSearchValue = CppDefSearchMacro(pszTokenName, &astMacroDef);

			if ( iSearchValue != TRUE || astMacroDef == 0 ) {
				/* マクロではない */
				astStart ++;
			}else {
				/* マクロです */
				ulDefined = stCoreMacroDefInfoAccess.bValid.get( astMacroDef );
				if (ulDefined == FALSE) {
					/* 未定義 */
					astStart ++;
				}else {
					/* 定義した */

					nRet = CppRepTmpNewCtrl(astStart, pastEnd, astMacroDef);
					if (nRet != COEXIT_SUCCESS) {
						return (nRet);
					}
				}
			}
		}
	}

	return (COEXIT_SUCCESS);
}
